package nowcoder.hw.hj101;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.List;

//3868643487
public class Main1 {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        Integer numberCnt = Integer.valueOf(reader.readLine());
        String numbers = reader.readLine();
        String sortType =reader.readLine();

        Integer[] nums=new Integer[numberCnt];
        String[] split = numbers.split(" ");
        for (int i = 0; i < split.length; i++) {
            nums[i]=Integer.valueOf(split[i]);
        }
        sort(nums,0,numberCnt-1);

        StringBuilder sb =new StringBuilder();
        if (sortType.equals("0")){
            for (int i = 0; i < nums.length; i++) {
                sb.append(nums[i]+" ");
            }
        }
        else if (sortType.equals("1")){
            for (int i = nums.length-1; i >=0; i--) {
                sb.append(nums[i]+" ");
            }
        }
        System.out.println(sb.deleteCharAt(sb.length()-1).toString());
    }

    private static void sort(Integer[] nums, int start, int end) {
        System.out.println("start:"+start+"end:"+end);
        if (start >= end) return;
        int left=start+1,right=end;
        int mid = start;
        while (left<=right ) {
                //将比mid小的元素放左边，比mid元素大的放右边
                if (nums[mid] >= nums[left]) {
                    int t = nums[left];
                    nums[left] = nums[mid];
                    nums[mid] = t;
                    mid = left;
                    left++;
                } else if (nums[mid] < nums[left]) {
                    int t = nums[left];
                    nums[left] = nums[right];
                    nums[right] = t;
                    right--;
                }
        }
        sort(nums, start, mid-1);
        sort(nums, mid + 1, end);
    }


    public static void quickSort(Integer[] arr, int start, int end) {
        // 如果区域内的数字少于 2 个，退出递归
        if (start >= end) return;
        // 将数组分区，并获得中间值的下标
        int middle = partition(arr, start, end);
        // 对左边区域快速排序
        quickSort(arr, start, middle - 1);
        // 对右边区域快速排序
        quickSort(arr, middle + 1, end);
    }

    // 将 arr 从 start 到 end 分区，左边区域比基数小，右边区域比基数大，然后返回中间值的下标
    public static int partition(Integer[] arr, int start, int end) {
        // 取第一个数为基数
        int pivot = arr[start];
        // 从第二个数开始分区
        int left = start + 1;
        // 右边界
        int right = end;
        // left、right 相遇时退出循环
        while (left < right) {
            // 找到第一个大于基数的位置
            while (left < right && arr[left] <= pivot) left++;
            // 交换这两个数，使得左边分区都小于或等于基数，右边分区大于或等于基数
            if (left != right) {
                exchange(arr, left, right);
                right--;
            }
        }
        // 如果 left 和 right 相等，单独比较 arr[right] 和 pivot
        if (left == right && arr[right] > pivot) right--;
        // 将基数和中间数交换
        if (right != start) exchange(arr, start, right);
        // 返回中间值的下标
        return right;
    }

    private static void exchange(Integer[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }


}